﻿/*
* ========================================================================
* 类说明：
*   卓品 LIN 盒操作相关
* 
* 作者：HGS   时间：2024/8/26 10:15:15
* 
* 修改者：         时间：           
* 修改说明：
* ========================================================================
*/

using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using VM.Shared.TestAttribute;

namespace 卓品蓝牙盒
{
    [ExposedMethodAttribute("卓品LIN盒控制")]
    public class LIN盒
    {
        /// <summary>
        /// 串口
        /// </summary>
        private SerialPort serialPort;
        /// <summary>
        /// 读取到的数据
        /// </summary>
        private string ReadData = "";


        /// <summary>
        /// 打开串口
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="信息"></param>
        /// <returns></returns>
        private bool OpenPort(string 串口, out string 信息)
        {
            信息 = "";
            for (int i = 0; i < 3; i++)
            {
                try
                {
                    信息 = "";
                    serialPort = new SerialPort(串口, 115200, Parity.None, 8, StopBits.One); // 设置串口参数
                    Thread.Sleep(10);
                    serialPort.Open(); // 打开串口
                    return true;
                }
                catch (Exception ex)
                {
                    信息 = ex.Message;
                }
            }

            return false;
        }
        /// <summary>
        /// 关闭串口
        /// </summary>
        private void ClosePort()
        {
            if (serialPort.IsOpen)
            {
                serialPort.Close(); // 关闭串口
            }
            serialPort = null;
        }
        /// <summary>
        /// 串口发送并接收返回数据
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="sendData"></param>
        /// <param name="比较"></param>
        /// <param name="信息"></param>
        /// <returns></returns>
        private bool 发送接收(string 串口, string sendData, out string 错误信息)
        {
            try
            {
                错误信息 = "";
                ReadData = "";

                if (!OpenPort(串口, out 错误信息))
                {
                    return false;
                }

                Thread.Sleep(20);
                if (serialPort.IsOpen)
                {
                    serialPort.Write(sendData); // 写入数据
                    //Console.WriteLine("发送数据" + sendData);
                    Thread.Sleep(100);

                    ReadData = serialPort.ReadExisting();
                    return true;
                }
                else
                {
                    错误信息 = "串口未打开";
                }
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            finally
            {
                ClosePort();  //关闭串口
            }
            return false;
        }


        //=============================== 系统设置 =========================================================
        /// <summary>
        /// 配置模式查询
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="配置模式">
        /// 0   关
        /// 1   开
        /// </param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 配置模式查询(string 串口, out string 配置模式, out string 错误信息)
        {
            配置模式 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, "MODULECONFMOD?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (ReadData.Contains("0") || ReadData.Contains("1"))
                {
                    配置模式 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }
        /// <summary>
        /// 配置模式设置
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="配置模式">
        /// 0   关
        /// 1   开
        /// </param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 配置模式设置(string 串口, string 配置模式, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                //0表示退出配置模式，1 表示进入配置模式
                if (!发送接收(串口, $"MODULECONFMOD:{配置模式}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        /// <summary>
        /// 设备信息查询
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="设备信息">成功时应答设备型号</param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 设备信息查询(string 串口, out string 设备信息, out string 错误信息)
        {
            设备信息 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"*IDN?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    设备信息 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        /// <summary>
        /// 硬件版本查询
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="硬件版本">成功时应答硬件版本号</param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 硬件版本查询(string 串口, out string 硬件版本, out string 错误信息)
        {
            硬件版本 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"*VH?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    硬件版本 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        /// <summary>
        /// 软件版本查询
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="软件版本">成功时应答软件版本号</param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 软件版本查询(string 串口, out string 软件版本, out string 错误信息)
        {
            软件版本 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"*VS?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    软件版本 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }

        /// <summary>
        /// 系统复位设置
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 系统复位设置(string 串口, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"*RST", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }
        /// <summary>
        /// 设置参数保存
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 设置参数保存(string 串口, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"*SAVE!", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }
        /// <summary>
        /// 运行数据保存
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 运行数据保存(string 串口, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"*SAVE1!", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }
        /// <summary>
        /// 恢复出厂设置
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 恢复出厂设置(string 串口, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"*INIT!", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }


        //=============================== 主控（RS232）设置 =========================================================
        /// <summary>
        /// 串口波特率查询
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="串口波特率">成功时，返回当前 RS232 波特率，例如"9600"</param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 串口波特率查询(string 串口, out string 串口波特率, out string 错误信息)
        {
            串口波特率 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"ME0A:UABD?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    串口波特率 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        /// <summary>
        /// 串口波特率设置
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="串口波特率">波特率，例如 9600、115200 等</param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 串口波特率设置(string 串口, string 串口波特率, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"UABD:{串口波特率}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        /// <summary>
        /// 串口结束符查询
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="串口结束符">
        /// 0 -> 无结束符 或 自适应结束符（出厂默认值)
        /// 1 -> 结束符为[LF]    ASCLL值为 0x0A (Hex)
        /// 2 -> 结束符为[CR]    ASCLL值为 0x0D (Hex)
        /// 3 -> 结束符为[RS]    ASCLL值为 0x1E (Hex)
        /// 4 -> 结束符为[CR/LF] ASCLL值为 0x0D 0x0A (Hex)
        /// </param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 串口结束符查询(string 串口, out string 串口结束符, out string 错误信息)
        {
            串口结束符 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"UAEND？", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    串口结束符 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        /// <summary>
        /// 串口结束符设置
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="LIN波特率"></param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 串口结束符设置(string 串口, string 串口结束符, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"UAEND:{串口结束符}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }


        //=============================== 从控（UART）设置 =========================================================
        [ExposedMethodAttribute("")]
        public bool 从控速率查询(string 串口, out string 从控速率, out string 错误信息)
        {
            从控速率 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"UABD2?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    从控速率 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }


        //=============================== LIN通信设置 =========================================================
        /// <summary>
        /// LIN波特率查询
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="LIN波特率">成功时，返回当前 LIN 波特率，单位为 bps</param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool LIN波特率查询(string 串口, out string LIN波特率, out string 错误信息)
        {
            LIN波特率 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LIBD?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    LIN波特率 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool LIN波特率设置(string 串口, string LIN波特率, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LIBD:{LIN波特率}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        [ExposedMethodAttribute("")]
        public bool LIN报头接收间隔时间bit查询(string 串口, out string LIN报头接收间隔时间bit, out string 错误信息)
        {
            LIN报头接收间隔时间bit = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LISPB?", out 错误信息))
                {
                    return false;
                }

                //解析数据：返回 LIN 报头接收间隔时间值，单位为 1bit 时间
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    LIN报头接收间隔时间bit = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool LIN报头接收间隔时间bit设置(string 串口, string LIN报头接收间隔时间bit, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LISPB:{LIN报头接收间隔时间bit}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        [ExposedMethodAttribute("")]
        public bool LIN报头接收间隔时间us查询(string 串口, out string LIN报头接收间隔时间us, out string 错误信息)
        {
            LIN报头接收间隔时间us = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LISPT?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    LIN报头接收间隔时间us = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool LIN报头接收间隔时间us设置(string 串口, string LIN报头接收间隔时间us, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LISPT:{LIN报头接收间隔时间us}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        [ExposedMethodAttribute("")]
        public bool LIN响应接收间隔时间bit查询(string 串口, out string LIN响应接收间隔时间bit, out string 错误信息)
        {
            LIN响应接收间隔时间bit = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LIREB?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    LIN响应接收间隔时间bit = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool LIN响应接收间隔时间bit设置(string 串口, string LIN响应接收间隔时间bit, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LIREB:{LIN响应接收间隔时间bit}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        [ExposedMethodAttribute("")]
        public bool LIN响应接收间隔时间us查询(string 串口, out string LIN响应接收间隔时间us, out string 错误信息)
        {
            LIN响应接收间隔时间us = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LIRET?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    LIN响应接收间隔时间us = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool LIN响应接收间隔时间us设置(string 串口, string LIN响应接收间隔时间us, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LIRET:{LIN响应接收间隔时间us}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        [ExposedMethodAttribute("")]
        public bool LIN工作模式查询(string 串口, out string LIN工作模式, out string 错误信息)
        {
            LIN工作模式 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LIMD?", out 错误信息))
                {
                    return false;
                }

                //解析数据：成功返回当前工作模式编号
                /* 工作模式返回值说明：
                     0：不接收 LIN 总线上的数据
                     1：只在本主机发送报头后一定间隔时间内接收 LIN 总线上其它子机的响应。
                     2：接收 LIN 总线上的报头 或 报头+响应
                     3：同时具备 LIN 主机和 LIN 从机接收数据的特性
                     4：只接收本机发送到 LIN 总线上的 LIN报文
                     5：接收 LIN 总线上的任何数据，不作任何处理，直接由串口转发
                 */
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    LIN工作模式 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool LIN工作模式设置(string 串口, string LIN工作模式, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LIMD:{LIN工作模式}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        [ExposedMethodAttribute("")]
        public bool LIN接收数据格式查询(string 串口, out string LIN接收数据格式, out string 错误信息)
        {
            LIN接收数据格式 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LIFM?", out 错误信息))
                {
                    return false;
                }

                //解析数据：返回当数据转发格式
                //0 -> 原值，不做任何转换（开机默认值）
                //1 -> 转化为 16 进制字符串
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    LIN接收数据格式 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool LIN接收数据格式设置(string 串口, string LIN接收数据格式, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LIFM:{LIN接收数据格式}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        [ExposedMethodAttribute("")]
        public bool LIN_ID接口开关查询(string 串口, out string LIN_ID接口开关, out string 错误信息)
        {
            LIN_ID接口开关 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LIDF?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    LIN_ID接口开关 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool LIN_ID接口开关设置(string 串口, string LIN_ID接口开关, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LIDF:{LIN_ID接口开关}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        [ExposedMethodAttribute("")]
        public bool LIN协议版本查询(string 串口, out string LIN协议版本, out string 错误信息)
        {
            LIN协议版本 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LIVR?", out 错误信息))
                {
                    return false;
                }

                //解析数据：成功时，返回当前 LIN 协议版本编号
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    LIN协议版本 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool LIN协议版本设置(string 串口, string LIN协议版本, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LIVR:{LIN协议版本}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }


        //=============================== LIN发送主机报文（配置模式下） =========================================================
        [ExposedMethodAttribute("")]
        public bool LIN发送主机报文_配置模式下(string 串口, string 发送数据, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"48 3A {发送数据}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //发送成功无应答，发送失败返回错误代码
                if (string.IsNullOrWhiteSpace(ReadData))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }
        [ExposedMethodAttribute("")]
        public bool LIN发送从机响应_配置模式下(string 串口, string 发送数据, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"68 3A {发送数据}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //发送成功无应答，发送失败返回错误代码
                if (string.IsNullOrWhiteSpace(ReadData))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }


        //=============================== LIN发送数据（非配置模式下） =========================================================
        [ExposedMethodAttribute("")]
        public bool LIN发送数据_非配置模式下(string 串口, string 发送数据, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"{发送数据}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //发送成功无应答，发送失败返回错误代码
                if (string.IsNullOrWhiteSpace(ReadData))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        [ExposedMethodAttribute("")]
        public bool 大灯控制查询(string 串口, out string 大灯控制, out string 错误信息)
        {
            大灯控制 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"48 3A 0B", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    大灯控制 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool 大灯控制设置(string 串口,bool open, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                string sendCmd = "";
                if (open)
                {
                    sendCmd = "48 3A 0A 8f 20 10 00 00 00 00 00";  //全亮
                }
                else
                {
                    sendCmd = "48 3A 0A 00 00 00 00 00 00 00 00";  //全灭
                }

                if (!发送接收(串口, sendCmd, out 错误信息))
                {
                    return false;
                }

                //发送完毕不知道会不会有返回数据，先按照发送成功就返回 true 处理

                return true;
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        [ExposedMethodAttribute("")]
        public bool 风扇设置(string 串口, bool open, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                string sendCmd = "";
                if (open)
                {
                    sendCmd = "48 3A 0C 02";  //打开
                }
                else
                {
                    sendCmd = "48 3A 0C 01";  //关闭
                }

                if (!发送接收(串口, sendCmd, out 错误信息))
                {
                    return false;
                }

                //发送完毕不知道会不会有返回数据，先按照发送成功就返回 true 处理

                return true;
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }


        //=============================== LIN从机自动响应 =========================================================
        [ExposedMethodAttribute("")]
        public bool LIN从机自动响应开启状态查询(string 串口, out string LIN从机自动响应开启状态, out string 错误信息)
        {
            LIN从机自动响应开启状态 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"DRMOD?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    LIN从机自动响应开启状态 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        /// <summary>
        /// 自动响应开关控制
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="LIN从机自动响应开启状态">
        /// 0   关
        /// 1   开
        /// </param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool LIN从机自动响应开启状态设置(string 串口, string LIN从机自动响应开启状态, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"DRMOD:{LIN从机自动响应开启状态}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        [ExposedMethodAttribute("")]
        public bool 查询数据响应器中的数据条数(string 串口, out string 数据响应器中的数据条数, out string 错误信息)
        {
            数据响应器中的数据条数 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"DRBUFN?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    数据响应器中的数据条数 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        /// <summary>
        /// 数据响应器数据清空：清空数据响应器中的所有数据
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 数据响应器数据清空(string 串口, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"DRBUFN:CLEAR", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        /// <summary>
        /// 过滤数据查询：读取当前过滤器中的所有数据
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="过滤数据"></param>
        /// <param name="错误信息"></param>
        /// <param name="返回数据格式">
        /// 0   原值形式
        /// 1   字符串形式
        /// </param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 数据响应器查询(string 串口, out string 返回数据, out string 错误信息, int 返回数据格式 = 1)
        {
            返回数据 = "";
            错误信息 = "";

            try
            {
                bool sendAndReceiveResult = false;

                switch (返回数据格式)
                {
                    case 0:
                        sendAndReceiveResult = 发送接收(串口, $"DRBUFS?", out 错误信息);
                        break;
                    case 1:
                        sendAndReceiveResult = 发送接收(串口, $"DRBUFH?", out 错误信息);
                        break;
                    default:
                        break;
                }

                if (!sendAndReceiveResult)
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    返回数据 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        /// <summary>
        /// 数据响应器设置：向数据响应器中写入 1 条数据
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="写入数据"></param>
        /// <param name="错误信息"></param>
        /// <param name="写入数据格式">
        /// 0   写入数据为 LIN 数据原值
        /// 1   写入数据为 LIN 数据字符串
        /// </param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 数据响应器设置(string 串口, string 写入数据, out string 错误信息, int 写入数据格式 = 1)
        {
            错误信息 = "";

            try
            {
                bool sendAndReceiveResult = false;

                switch (写入数据格式)
                {
                    case 0:
                        sendAndReceiveResult = 发送接收(串口, $"44 52 42 55 46 53 3A {写入数据}", out 错误信息);
                        break;
                    case 1:
                        sendAndReceiveResult = 发送接收(串口, $"DRBUFH:{写入数据}", out 错误信息);
                        break;
                    default:
                        break;
                }

                if (!sendAndReceiveResult)
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }


        //=============================== 数据过滤功能 =========================================================
        [ExposedMethodAttribute("")]
        public bool 过滤模式查询(string 串口, out string 过滤模式, out string 错误信息)
        {
            过滤模式 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"DFMOD?", out 错误信息))
                {
                    return false;
                }

                //解析数据：返回当前过滤模式值
                //0 -> 数据过滤器关闭，总线上的所有 LIN 报文，均能被接收！（开机默认值）
                //1 -> 包含通过：当接收到的数据包含过滤数组的任何 1 条数据时，此接收数据才被保留, 否则将被废弃!
                //2 -> 相等通过：当接收到的数据完全等于过滤数组中的某条数据时，此接收数据才被保留, 否则将被废弃!
                //3 -> 不包含通过：和 包含通过 相反，当接收到的数据包含过滤数组的任何 1 条数据时，此接收数据被废弃, 否则将被保留!
                //4 -> 不相等通过：和 相等通过 相反，当接收到的数据完全等于过滤数组中的某条数据时，此接收数据被废弃, 否则将被保留!

                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    过滤模式 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool 过滤模式设置(string 串口, string 过滤模式, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"DFMOD:{过滤模式}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        [ExposedMethodAttribute("")]
        public bool 查询当前过滤器中的数据条数(string 串口, out string 当前过滤器中的数据条数, out string 错误信息)
        {
            当前过滤器中的数据条数 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"DFBUFN?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    当前过滤器中的数据条数 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        /// <summary>
        /// 过滤数据清空：清除过滤器中的所有数据
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="过滤模式"></param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 过滤数据清空(string 串口, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"DFBUFN:CALEAR", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        /// <summary>
        /// 过滤数据查询：读取当前过滤器中的所有数据
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="过滤数据"></param>
        /// <param name="错误信息"></param>
        /// <param name="返回数据格式">
        /// 0   以原数据形式返回过滤器中的所有数据
        /// 1   以数据字符串形式返回过滤器中的所有数据
        /// </param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 过滤数据查询(string 串口, out string 过滤数据, out string 错误信息, int 返回数据格式 = 1)
        {
            过滤数据 = "";
            错误信息 = "";

            try
            {
                bool sendAndReceiveResult = false;

                switch (返回数据格式)
                {
                    case 0:
                        sendAndReceiveResult = 发送接收(串口, $"DFBUFS?", out 错误信息);
                        break;
                    case 1:
                        sendAndReceiveResult = 发送接收(串口, $"DFBUFH?", out 错误信息);
                        break;
                    default:
                        break;
                }

                if (!sendAndReceiveResult)
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    过滤数据 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        /// <summary>
        /// 过滤数据设置：向过滤器中写入 1 条数据
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="写入数据"></param>
        /// <param name="错误信息"></param>
        /// <param name="写入数据格式">
        /// 0   写入数据为 LIN 数据原值
        /// 1   写入数据为 LIN 数据字符串
        /// </param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool 过滤数据设置(string 串口, string 写入数据, out string 错误信息, int 写入数据格式 = 1)
        {
            错误信息 = "";

            try
            {
                bool sendAndReceiveResult = false;

                switch (写入数据格式)
                {
                    case 0:
                        sendAndReceiveResult = 发送接收(串口, $"44 46 42 55 46 53 3A {写入数据}", out 错误信息);
                        break;
                    case 1:
                        sendAndReceiveResult = 发送接收(串口, $"DFBUFH:{写入数据}", out 错误信息);
                        break;
                    default:
                        break;
                }

                if (!sendAndReceiveResult)
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }



        /******************************* 以下指令是文档中没有记录的（但设备通信助手上面有）***********************/
        //=============================== 设备端IO控制 ============================================================
        [ExposedMethodAttribute("")]
        public bool 线路接通状态查询(string 串口, out string 线路接通状态, out string 错误信息)
        {
            线路接通状态 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"EGSW?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    线路接通状态 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool 线路接通状态设置(string 串口, string 线路接通状态, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"EGSW:{线路接通状态}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        [ExposedMethodAttribute("")]
        public bool EIO类型查询(string 串口, out string EIO类型, out string 错误信息)
        {
            EIO类型 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"EGTP?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    EIO类型 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool EIO类型设置(string 串口, string EIO类型, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"EGTP:{EIO类型}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        [ExposedMethodAttribute("")]
        public bool EIO查询(string 串口, out string EIO, out string 错误信息)
        {
            EIO = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"EGST?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    EIO = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        /// <summary>
        /// EIO设置
        /// </summary>
        /// <param name="串口"></param>
        /// <param name="EIO">
        /// 0   输出低电平
        /// 1   输出高电平
        /// </param>
        /// <param name="错误信息"></param>
        /// <returns></returns>
        [ExposedMethodAttribute("")]
        public bool EIO设置(string 串口, string EIO, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"EGST:{EIO}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }


        //=============================== ID&多机通信设置 =========================================================
        [ExposedMethodAttribute("")]
        public bool 设备ID查询(string 串口, out string 设备ID, out string 错误信息)
        {
            设备ID = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"ID?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    设备ID = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool 设备ID设置(string 串口, string 设备ID, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"ID:{设备ID}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        [ExposedMethodAttribute("")]
        public bool ID查询_广播(string 串口, out string ID, out string 错误信息)
        {
            ID = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LN255:ID?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    ID = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool ID设置_广播(string 串口, string ID, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"LN255:ID:{ID}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }


        //=============================== 总线类型设置 ============================================================
        [ExposedMethodAttribute("")]
        public bool 总线类型查询(string 串口, out string 总线类型, out string 错误信息)
        {
            总线类型 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"BUS:TYPE?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    总线类型 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool 总线类型设置(string 串口, string 总线类型, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"BUS:TYPE:{总线类型}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        [ExposedMethodAttribute("")]
        public bool 总线速率查询(string 串口, out string 总线速率, out string 错误信息)
        {
            总线速率 = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"BUS:BAUD?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    总线速率 = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        [ExposedMethodAttribute("")]
        public bool 总线速率设置(string 串口, string 总线速率, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"BUS:BAUD:{总线速率}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }


        //=============================== ISF一线通发送数据 =======================================================
        [ExposedMethodAttribute("")]
        public bool ISF一线通发送数据_带校验(string 串口, string 发送数据, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"41 3A {发送数据}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //发送成功无应答，发送失败返回错误代码
                if (string.IsNullOrWhiteSpace(ReadData))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }
        [ExposedMethodAttribute("")]
        public bool ISF一线通发送数据_无校验(string 串口, string 发送数据, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"61 3A {发送数据}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //发送成功无应答，发送失败返回错误代码
                if (string.IsNullOrWhiteSpace(ReadData))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }


        //=============================== K线发送数据 =============================================================
        [ExposedMethodAttribute("")]
        public bool K线发送数据(string 串口, string 发送数据, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"4B 3A {发送数据}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //发送成功无应答，发送失败返回错误代码
                if (string.IsNullOrWhiteSpace(ReadData))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }


        //=============================== 工厂调试指令（先不对外开放） ============================================================
        public bool 串口收发间隔byte查询(string 串口, out string 串口收发间隔byte, out string 错误信息)
        {
            串口收发间隔byte = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"UASPB?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    串口收发间隔byte = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        public bool 串口收发间隔byte设置(string 串口, string 串口收发间隔yte, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"UASPB:{串口收发间隔yte}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }

        public bool 串口收发间隔us查询(string 串口, out string 串口收发间隔us, out string 错误信息)
        {
            串口收发间隔us = "";
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"UASPT?", out 错误信息))
                {
                    return false;
                }

                //解析数据
                if (!string.IsNullOrWhiteSpace(ReadData))
                {
                    串口收发间隔us = ReadData;
                    return true;
                }

                错误信息 = $"返回数据为空";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }

            return false;
        }
        public bool 串口收发间隔us设置(string 串口, string 串口收发间隔us, out string 错误信息)
        {
            错误信息 = "";

            try
            {
                if (!发送接收(串口, $"UASPT:{串口收发间隔us}", out 错误信息))
                {
                    return false;
                }

                //解析数据
                //成功时应答 ACK
                if (ReadData.ToUpper().Contains("ACK"))
                {
                    return true;
                }

                错误信息 = $"返回数据不正确，{ReadData}";
            }
            catch (Exception ex)
            {
                错误信息 = ex.Message;
            }
            return false;
        }
    }
}
